// 权限验证工具类
class AuthUtil {
  constructor() {
    this.baseURL = 'http://101.42.232.154:10010';
    this.token = uni.getStorageSync('token') || '';
    this.platform = this.getPlatform();
    this.userInfo = uni.getStorageSync('userInfo') || null;
  }

  // 获取当前平台
  getPlatform() {
    // #ifdef H5
    return 'web';
    // #endif
    
    // #ifdef MP-WEIXIN
    return 'miniprogram';
    // #endif
    
    // #ifdef APP-PLUS
    return 'app';
    // #endif
    
    return 'unknown';
  }

  // 设置token
  setToken(token) {
    this.token = token;
    uni.setStorageSync('token', token);
  }

  // 设置用户信息
  setUserInfo(userInfo) {
    this.userInfo = userInfo;
    uni.setStorageSync('userInfo', userInfo);
  }

  // 清除登录信息
  clearAuth() {
    this.token = '';
    this.userInfo = null;
    uni.removeStorageSync('token');
    uni.removeStorageSync('userInfo');
  }

  // 获取请求头
  getHeaders() {
    const headers = {
      'Content-Type': 'application/json',
      'Platform': this.platform
    };
    
    if (this.token) {
      headers['Authorization'] = this.token;
    }
    
    return headers;
  }

  // 通用请求方法
  async request(url, options = {}) {
    const config = {
      url: this.baseURL + url,
      method: 'GET',
      header: this.getHeaders(),
      ...options
    };

    try {
      const response = await uni.request(config);
      const { statusCode, data } = response[1];
      
      if (statusCode === 200) {
        if (data.status === 200) {
          return data;
        } else {
          // 处理业务错误
          this.handleBusinessError(data);
          return data;
        }
      } else {
        // 处理HTTP错误
        this.handleHttpError(statusCode);
        return null;
      }
    } catch (error) {
      console.error('请求失败:', error);
      uni.showToast({
        title: '网络请求失败',
        icon: 'none'
      });
      return null;
    }
  }

  // 处理业务错误
  handleBusinessError(data) {
    const errorMessages = {
      10001: '数据异常，处理失败',
      10002: '专业不存在',
      10003: '权限不足',
      10004: '账号或密码错误',
      10005: '导员编号不存在',
      10006: '账号或密码为空',
      10007: '未绑定学生信息',
      10008: '学号不存在'
    };

    const message = errorMessages[data.status] || data.message || '未知错误';
    
    // 特殊处理权限不足的情况
    if (data.status === 10003) {
      uni.showModal({
        title: '权限提示',
        content: '当前平台不支持此功能，请使用正确的客户端访问',
        showCancel: false
      });
    } else {
      uni.showToast({
        title: message,
        icon: 'none'
      });
    }
  }

  // 处理HTTP错误
  handleHttpError(statusCode) {
    const message = statusCode >= 500 ? '服务器错误' : '请求失败';
    uni.showToast({
      title: message,
      icon: 'none'
    });
  }

  // 检查是否有权限访问
  hasPermission(requiredPlatform, requiredRoles = []) {
    // 检查平台权限
    if (requiredPlatform && this.platform !== requiredPlatform) {
      return false;
    }
    
    // 检查角色权限（如果有token的话）
    if (requiredRoles.length > 0 && this.token) {
      try {
        const payload = JSON.parse(atob(this.token.split('.')[1]));
        return requiredRoles.some(role => payload.role && payload.role.includes(role));
      } catch (error) {
        return false;
      }
    }
    
    return true;
  }

  // 检查是否已登录（仅Web端需要）
  isLoggedIn() {
    return this.platform === 'web' ? !!this.token : true;
  }

  // 获取默认首页路径
  getDefaultHomePage() {
    if (this.platform === 'web') {
      // Web端：如果已登录，根据角色跳转；否则跳转登录页
      if (this.isLoggedIn()) {
        return this.getRoleHomePage();
      } else {
        return '/pages/login/index';
      }
    } else {
      // 小程序端：直接跳转学生首页
      return '/pages/dashboard/index';
    }
  }

  // 根据角色获取首页路径
  getRoleHomePage() {
    if (!this.userInfo || !this.userInfo.role) {
      return '/pages/login/index';
    }

    const role = this.userInfo.role[0]; // 取第一个角色
    switch (role) {
      case 'counselor':
        return '/pages/admin/index?role=counselor';
      case 'faculty':
        return '/pages/admin/index?role=faculty';
      case 'office':
        return '/pages/admin/index?role=office';
      default:
        return '/pages/login/index';
    }
  }

  // 学生端专用方法
  async studentBinding(studentId, unionId) {
    if (!this.hasPermission('miniprogram')) {
      uni.showToast({
        title: '此功能仅支持小程序端',
        icon: 'none'
      });
      return null;
    }

    return this.request('/student/binding', {
      method: 'POST',
      data: {
        id: studentId,
        unionId: unionId
      }
    });
  }

  // 获取学生信息
  async getStudentInfo(unionId) {
    if (!this.hasPermission('miniprogram')) {
      uni.showToast({
        title: '此功能仅支持小程序端',
        icon: 'none'
      });
      return null;
    }

    return this.request('/student/info', {
      method: 'GET',
      data: { unionId }
    });
  }

  // 定位报道
  async positioningReport(unionId, latitude, longitude) {
    if (!this.hasPermission('miniprogram')) {
      uni.showToast({
        title: '此功能仅支持小程序端',
        icon: 'none'
      });
      return null;
    }

    return this.request('/student/positioning', {
      method: 'POST',
      data: {
        unionId,
        latitude,
        longitude
      }
    });
  }

  // 教师端专用方法
  async adminLogin(account, password) {
    if (!this.hasPermission('web')) {
      uni.showToast({
        title: '此功能仅支持Web端',
        icon: 'none'
      });
      return null;
    }

    return this.request('/user/login', {
      method: 'POST',
      data: {
        account: account,
        password: password
      }
    });
  }

  // 获取管理员信息
  async getAdminInfo() {
    if (!this.hasPermission('web')) {
      uni.showToast({
        title: '此功能仅支持Web端',
        icon: 'none'
      });
      return null;
    }

    return this.request('/user/info', {
      method: 'POST'
    });
  }

  // 退出登录
  async logout() {
    if (!this.hasPermission('web')) {
      uni.showToast({
        title: '此功能仅支持Web端',
        icon: 'none'
      });
      return null;
    }

    const result = await this.request('/user/logout', {
      method: 'GET'
    });
    
    if (result && result.status === 200) {
      this.clearAuth();
    }
    
    return result;
  }
}

export default new AuthUtil(); 